<html>
 <head>
  <meta charset="UTF-8">
 </head>
 <body>
  <h1 data-lake-id="TmhCp" id="TmhCp"><span data-lake-id="u43bc313f" id="u43bc313f">典型回答</span></h1>
  <p data-lake-id="u706f7f55" id="u706f7f55"><br></p>
  <p data-lake-id="u055b2407" id="u055b2407"><strong><span data-lake-id="u502a196a" id="u502a196a">在JDK 1.7中，ConcurrentHashMap使用了分段锁技术</span></strong><span data-lake-id="uf9552872" id="uf9552872">，即将哈希表分成多个段，每个段拥有一个独立的锁。这样可以在多个线程同时访问哈希表时，只需要锁住需要操作的那个段，而不是整个哈希表，从而提高了并发性能。</span></p>
  <p data-lake-id="uf56b1d70" id="uf56b1d70"><span data-lake-id="u5fb94f45" id="u5fb94f45">​</span><br></p>
  <p data-lake-id="uddc5a017" id="uddc5a017"><span data-lake-id="ub16e065d" id="ub16e065d">虽然JDK 1.7的这种方式可以减少锁竞争，但是在高并发场景下，仍然会出现锁竞争，从而导致性能下降。</span></p>
  <p data-lake-id="u453a13db" id="u453a13db"><span data-lake-id="uf59b3437" id="uf59b3437">​</span><br></p>
  <p data-lake-id="u2f7608ef" id="u2f7608ef"><strong><span data-lake-id="u20ce717b" id="u20ce717b">在JDK 1.8中，ConcurrentHashMap的实现方式进行了改进，使用分段锁（思想）和“CAS+Synchronized”的机制来保证线程安全。</span></strong><span data-lake-id="u7d02c9d9" id="u7d02c9d9">在JDK 1.8中，ConcurrentHashMap会在添加元素时，如果某个段为空，那么使用CAS操作来添加新节点；如果段不为空，使用Synchronized锁住当前段，再次尝试put。这样可以避免分段锁机制下的锁粒度太大，以及在高并发场景下，由于线程数量过多导致的锁竞争问题，提高了并发性能。</span></p>
  <p data-lake-id="u54447cb1" id="u54447cb1"><span data-lake-id="u01ed713a" id="u01ed713a">​</span><br></p>
  <blockquote data-lake-id="u83cb8fd2" id="u83cb8fd2">
   <p data-lake-id="ud62b2e49" id="ud62b2e49"><span data-lake-id="u5451bf13" id="u5451bf13">分段锁其实是一种思想。1.7中的"分段锁"和1.8中的"分段锁"不是一回事儿， 而当我们说1.7的分段锁，一般特指是他的Segment，而1.8中我们指的是一种分段加锁的思想，加锁的时候只对当前段加锁，而不是整个map加锁。</span></p>
  </blockquote>
  <p data-lake-id="u85e98806" id="u85e98806"><br></p>
  <h1 data-lake-id="gJGbP" id="gJGbP"><span data-lake-id="ue4458123" id="ue4458123">扩展知识</span></h1>
  <p data-lake-id="ubd8ead4d" id="ubd8ead4d"><br></p>
  <h2 data-lake-id="xD0j0" id="xD0j0"><span data-lake-id="uaa933e9c" id="uaa933e9c">源码分析</span></h2>
  <p data-lake-id="u8beee372" id="u8beee372"><br></p>
  <p data-lake-id="u41eb4175" id="u41eb4175"><span data-lake-id="u4ea26051" id="u4ea26051">ConcurrentHashMap将哈希表分成多个段，每个段拥有一个独立的锁，这样可以在多个线程同时访问哈希表时，只需要锁住需要操作的那个段，而不是整个哈希表，从而提高了并发性能。下面是ConcurrentHashMap中分段锁的代码实现：</span></p>
  <p data-lake-id="u8c95b9ee" id="u8c95b9ee"><span data-lake-id="u85bbb60a" id="u85bbb60a">​</span><br></p>
  <pre lang="java"><code>
static final class Node&lt;K,V&gt; implements Map.Entry&lt;K,V&gt; {
    final int hash;
    final K key;
    volatile V val;
    volatile Node&lt;K,V&gt; next;

    Node(int hash, K key, V val, Node&lt;K,V&gt; next) {
        this.hash = hash;
        this.key = key;
        this.val = val;
        this.next = next;
    }

    // ...
}

static final class Segment&lt;K,V&gt; extends ReentrantLock implements Serializable {
    private static final long serialVersionUID = 2249069246763182397L;
    transient volatile HashEntry&lt;K,V&gt;[] table;
    transient int count;
    transient int modCount;
    transient int threshold;
    final float loadFactor;
}

</code></pre>
  <p data-lake-id="u04e835cc" id="u04e835cc"><br></p>
  <p data-lake-id="u0532fd97" id="u0532fd97"><span data-lake-id="u6007b332" id="u6007b332">在上面的代码中，我们可以看到，每个Segment都是ReentrantLock的实现，每个Segment包含一个HashEntry数组，每个HashEntry则包含一个key-value键值对。</span></p>
  <p data-lake-id="uc4beaf3b" id="uc4beaf3b"><span data-lake-id="u717ce5fa" id="u717ce5fa">​</span><br></p>
  <p data-lake-id="uf903cbd4" id="uf903cbd4"><span data-lake-id="u3342c9e5" id="u3342c9e5">接下来再看下在JDK 1.8中，下面是ConcurrentHashMap中CAS+Synchronized机制的代码实现：</span></p>
  <p data-lake-id="u75d58f97" id="u75d58f97"><span data-lake-id="ue59c550a" id="ue59c550a">​</span><br></p>
  <pre lang="java"><code>
public V put(K key, V value) {
    if (value == null)
        throw new NullPointerException();

    // 对 key 的 hashCode 进行扰动
    int hash = spread(key.hashCode());
    int binCount = 0;

    // 循环操作
    for (Node&lt;K,V&gt;[] tab = table;;) {
        Node&lt;K,V&gt; f; int n, i, fh;

        // 如果 table 为 null 或长度为 0，则进行初始化
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();

            // 如果哈希槽为空，则通过 CAS 操作尝试插入新节点
        else if ((f = tabAt(tab, i = (n - 1) &amp; hash)) == null) {
            if (casTabAt(tab, i, null,
                         new Node&lt;K,V&gt;(hash, key, value, null)))
                break;
        }

            // 如果哈希槽处已经有节点，且 hash 值为 MOVED，则说明正在进行扩容，需要帮助迁移数据
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);

            // 如果哈希槽处已经有节点，且 hash 值不为 MOVED，则进行链表/红黑树的节点遍历或插入操作
        else {
            V oldVal = null;

            // 加锁，确保只有一个线程操作该节点的链表/红黑树
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh &gt;= 0) {
                        // 遍历链表，找到相同 key 的节点，更新值或插入新节点
                        binCount = 1;
                        for (Node&lt;K,V&gt; e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &amp;&amp;
                                ((ek = e.key) == key ||
                                 (ek != null &amp;&amp; key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node&lt;K,V&gt; pred = e;
                            if ((e = e.next) == null) {
                                // 将新节点插入到链表末尾
                                if (casNext(pred, new Node&lt;K,V&gt;(hash, key,
                                                                value, null))) {
                                    break;
                                }
                            }
                        }
                    }
                        // 遍历红黑树，找到相同 key 的节点，更新值或插入新节点
                    else if (f instanceof TreeBin) {
                        Node&lt;K,V&gt; p;
                        binCount = 2;
                        if ((p = ((TreeBin&lt;K,V&gt;)f).putTreeVal(hash, key,
                                                              value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            // 如果插入或更新成功，则进行可能的红黑树化操作
            if (binCount != 0) {
                if (binCount &gt;= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                // 如果替换旧值成功，则返回旧值
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    //

</code></pre>
  <p data-lake-id="u3efdf96f" id="u3efdf96f"><br></p>
  <p data-lake-id="ua0a2918b" id="ua0a2918b"><strong><span data-lake-id="u2139e067" id="u2139e067">在上述代码中，如果某个段为空，那么使用CAS操作来添加新节点；如果某个段中的第一个节点的hash值为MOVED，表示当前段正在进行扩容操作，那么就调用helpTransfer方法来协助扩容；否则，使用Synchronized锁住当前节点，然后进行节点的添加操作。</span></strong></p>
 </body>
</html>